﻿using MemoryViewControl;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;

namespace TestProject
{
    
    
    /// <summary>
    ///This is a test class for MemoryHexEditorControlTest and is intended
    ///to contain all MemoryHexEditorControlTest Unit Tests
    ///</summary>
  [TestClass()]
  public class MemoryHexEditorControlTest
  {


    private TestContext testContextInstance;

    /// <summary>
    ///Gets or sets the test context which provides
    ///information about and functionality for the current test run.
    ///</summary>
    public TestContext TestContext
    {
      get
      {
        return testContextInstance;
      }
      set
      {
        testContextInstance = value;
      }
    }

    #region Additional test attributes
    // 
    //You can use the following additional attributes as you write your tests:
    //
    //Use ClassInitialize to run code before running the first test in the class
    //[ClassInitialize()]
    //public static void MyClassInitialize(TestContext testContext)
    //{
    //}
    //
    //Use ClassCleanup to run code after all tests in a class have run
    //[ClassCleanup()]
    //public static void MyClassCleanup()
    //{
    //}
    //
    //Use TestInitialize to run code before running each test
    //[TestInitialize()]
    //public void MyTestInitialize()
    //{
    //}
    //
    //Use TestCleanup to run code after each test has run
    //[TestCleanup()]
    //public void MyTestCleanup()
    //{
    //}
    //
    #endregion


    /// <summary>
    ///A test for MemoryHexEditorControl Constructor
    ///</summary>
    [TestMethod()]
    public void MemoryHexEditorControlConstructorTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl();
      Assert.Inconclusive("TODO: Implement code to verify target");
    }

    /// <summary>
    ///A test for ByteToPrintableChar
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void ByteToPrintableCharTest()
    {
      byte b = 0; // TODO: Initialize to an appropriate value
      char expected = '.'; // TODO: Initialize to an appropriate value
      char actual;
      actual = MemoryHexEditorControl_Accessor.ByteToPrintableChar(b);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for CalculateRenderInfo
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void CalculateRenderInfoTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      target.CalculateRenderInfo();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for CalculateSizes
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void CalculateSizesTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      target.CalculateSizes();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for CheckVisibleMemory
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void CheckVisibleMemoryTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      target.CheckVisibleMemory();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for ClampAddress
    ///</summary>
    [TestMethod()]
    public void ClampAddressTest()
    {
      uint address = 0; // TODO: Initialize to an appropriate value
      int delta = 0; // TODO: Initialize to an appropriate value
      uint max = 0; // TODO: Initialize to an appropriate value
      uint expected = 0; // TODO: Initialize to an appropriate value
      uint actual;
      actual = MemoryHexEditorControl.ClampAddress(address, delta, max);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for Dispose
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void DisposeTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      bool disposing = false; // TODO: Initialize to an appropriate value
      target.Dispose(disposing);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for FillHexString
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void FillHexStringTest()
    {
      ushort val = 0; // TODO: Initialize to an appropriate value
      char[] chars = null; // TODO: Initialize to an appropriate value
      char[] charsExpected = null; // TODO: Initialize to an appropriate value
      int nibbles = 0; // TODO: Initialize to an appropriate value
      MemoryHexEditorControl_Accessor.FillHexString(val, ref chars, nibbles);
      Assert.AreEqual(charsExpected, chars);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for GetHighlightBrush
    ///</summary>
    [TestMethod()]
    public void GetHighlightBrushTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      int index = 0; // TODO: Initialize to an appropriate value
      Brush expected = null; // TODO: Initialize to an appropriate value
      Brush actual;
      actual = target.GetHighlightBrush(index);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for GetMaximumScrollAddress
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void GetMaximumScrollAddressTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      int lines = 0; // TODO: Initialize to an appropriate value
      uint expected = 0; // TODO: Initialize to an appropriate value
      uint actual;
      actual = target.GetMaximumScrollAddress(lines);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for GetMaximumVisibleBits
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void GetMaximumVisibleBitsTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      int expected = 0; // TODO: Initialize to an appropriate value
      int actual;
      actual = target.GetMaximumVisibleBits();
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for GetOffsetFromLine
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void GetOffsetFromLineTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      int line = 0; // TODO: Initialize to an appropriate value
      uint expected = 0; // TODO: Initialize to an appropriate value
      uint actual;
      actual = target.GetOffsetFromLine(line);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for InitializeComponent
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void InitializeComponentTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      target.InitializeComponent();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for IsInputKey
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void IsInputKeyTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      Keys keyData = new Keys(); // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.IsInputKey(keyData);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for MemorySpace_PropertyChanged
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void MemorySpace_PropertyChangedTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      object sender = null; // TODO: Initialize to an appropriate value
      PropertyChangedEventArgs args = null; // TODO: Initialize to an appropriate value
      target.MemorySpace_PropertyChanged(sender, args);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for MemorySpace_MemoryChanged
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void MemorySpace_RedrawTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      object sender = null; // TODO: Initialize to an appropriate value
      EventArgs args = null; // TODO: Initialize to an appropriate value
      target.MemorySpace_Redraw(sender, args);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnGetMemory
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnGetMemoryTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      MemoryHexEditorControl.GetMemoryEventArgs e = null; // TODO: Initialize to an appropriate value
      target.OnGetMemory(e);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnKeyDown
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnKeyDownTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      KeyEventArgs e = null; // TODO: Initialize to an appropriate value
      target.OnKeyDown(e);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnMemoryChanged
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnMemoryChangedTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      MemoryHexEditorControl.MemoryChangedEventArgs e = null; // TODO: Initialize to an appropriate value
      target.OnMemoryChanged(e);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnMouseDown
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnMouseDownTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      MouseEventArgs e = null; // TODO: Initialize to an appropriate value
      target.OnMouseDown(e);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnMouseMove
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnMouseMoveTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      MouseEventArgs e = null; // TODO: Initialize to an appropriate value
      target.OnMouseMove(e);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnMouseWheel
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnMouseWheelTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      MouseEventArgs e = null; // TODO: Initialize to an appropriate value
      target.OnMouseWheel(e);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnPaint
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnPaintTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      PaintEventArgs pe = null; // TODO: Initialize to an appropriate value
      target.OnPaint(pe);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnPropertyChanged
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnPropertyChangedTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      string propertyName = string.Empty; // TODO: Initialize to an appropriate value
      target.OnPropertyChanged(propertyName);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnResize
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnResizeTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      EventArgs e = null; // TODO: Initialize to an appropriate value
      target.OnResize(e);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnMemoryChanged
    ///</summary>
    [TestMethod()]
    public void RedrawMemoryTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      bool b = false; // TODO: Initialize to an appropriate value
      target.RedrawMemory(b);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetHighlightBrush
    ///</summary>
    [TestMethod()]
    public void SetHighlightBrushTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      int index = 0; // TODO: Initialize to an appropriate value
      Brush brush = null; // TODO: Initialize to an appropriate value
      target.SetHighlightBrush(index, brush);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for UpdateMousePosition
    ///</summary>
    [TestMethod()]
    public void UpdateMousePositionTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      target.UpdateMousePosition();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for timerGetMemory_Tick
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void timerGetMemory_TickTest()
    {
      MemoryHexEditorControl_Accessor target = new MemoryHexEditorControl_Accessor(); // TODO: Initialize to an appropriate value
      object sender = null; // TODO: Initialize to an appropriate value
      EventArgs e = null; // TODO: Initialize to an appropriate value
      target.timerGetMemory_Tick(sender, e);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for Columns
    ///</summary>
    [TestMethod()]
    public void ColumnsTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      int expected = 0; // TODO: Initialize to an appropriate value
      int actual;
      target.Columns = expected;
      actual = target.Columns;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for Grouping
    ///</summary>
    [TestMethod()]
    public void GroupingTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      int expected = 0; // TODO: Initialize to an appropriate value
      int actual;
      target.Grouping = expected;
      actual = target.Grouping;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for MemoryFont
    ///</summary>
    [TestMethod()]
    public void MemoryFontTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      Font expected = null; // TODO: Initialize to an appropriate value
      Font actual;
      target.MemoryFont = expected;
      actual = target.MemoryFont;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for MemorySpace
    ///</summary>
    [TestMethod()]
    public void MemorySpaceTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      MemorySpace expected = null; // TODO: Initialize to an appropriate value
      MemorySpace actual;
      target.MemorySpace = expected;
      actual = target.MemorySpace;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for Offset
    ///</summary>
    [TestMethod()]
    public void OffsetTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      uint expected = 0; // TODO: Initialize to an appropriate value
      uint actual;
      target.Offset = expected;
      actual = target.Offset;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for RenderHiddenBytes
    ///</summary>
    [TestMethod()]
    public void RenderHiddenBytesTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      target.RenderHiddenBytes = expected;
      actual = target.RenderHiddenBytes;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for RenderInvalidBytes
    ///</summary>
    [TestMethod()]
    public void RenderInvalidBytesTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      target.RenderInvalidBytes = expected;
      actual = target.RenderInvalidBytes;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for Selection
    ///</summary>
    [TestMethod()]
    public void SelectionTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      MemorySpace.ByteInfo[] expected = null; // TODO: Initialize to an appropriate value
      MemorySpace.ByteInfo[] actual;
      target.Selection = expected;
      actual = target.Selection;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for SelectionBytes
    ///</summary>
    [TestMethod()]
    public void SelectionBytesTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      byte[] expected = null; // TODO: Initialize to an appropriate value
      byte[] actual;
      target.SelectionBytes = expected;
      actual = target.SelectionBytes;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for SelectionLength
    ///</summary>
    [TestMethod()]
    public void SelectionLengthTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      uint expected = 0; // TODO: Initialize to an appropriate value
      uint actual;
      target.SelectionLength = expected;
      actual = target.SelectionLength;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for SelectionStart
    ///</summary>
    [TestMethod()]
    public void SelectionStartTest()
    {
      MemoryHexEditorControl target = new MemoryHexEditorControl(); // TODO: Initialize to an appropriate value
      uint expected = 0; // TODO: Initialize to an appropriate value
      uint actual;
      target.SelectionStart = expected;
      actual = target.SelectionStart;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }
  }
}
